home *** CD-ROM | disk | FTP | other *** search
/ Alles Voor Internet / Tout Pour Internet / alles voor internet.iso / MacInternet™ / Telnet / NCSA / tn3270 2.4d7 source / tn3270 / writesf.c < prev    next >
Text File  |  1992-04-17  |  43KB  |  1,518 lines
  1. /*
  2.  *  tn3270 for the Macintosh Source Code
  3.  *  Brown University Computing and Information Services
  4.  *  Version 2.4d7  April, 1992
  5.  *  Copyright (c) 1988, 1989, 1990, 1991, 1992 by Brown University and by
  6.  *  Peter John DiCamillo.
  7.  *
  8.  *  Permission is granted to any individual or institution to use, copy,
  9.  *  or redistribute the binary version of this software and its
  10.  *  documentation provided this notice and the copyright notices are
  11.  *  retained.  Permission is granted to any individual or non-profit
  12.  *  institution to use, copy, modify, or redistribute the source files
  13.  *  of this software provided this notice and the copyright notices are
  14.  *  retained.  This software may not be distributed for profit, either
  15.  *  in original form or in derivative works, nor can the source be
  16.  *  distributed to other than an individual or a non-profit institution.
  17.  *  Any  individual or group interested in seeing and/or using these
  18.  *  source files but who are prevented from doing so by the above
  19.  *  constraints should contact Don Wolfe, Assistant Vice-President for
  20.  *  Computer Systems at Brown University, (401) 863-7250, for possible
  21.  *  software licensing of the source developed at Brown.
  22.  *
  23.  *  Brown University and Peter John DiCamillo make no representations
  24.  *  about the suitability of this software for any purpose.
  25.  *
  26.  *  BROWN UNIVERSITY AND PETER JOHN DICAMILLO GIVE NO WARRANTY, EITHER
  27.  *  EXPRESS OR IMPLIED, FOR THE PROGRAM AND/OR DOCUMENTATION PROVIDED,
  28.  *  INCLUDING, WITHOUT LIMITATION, WARRANTY OF MERCHANTABILITY AND
  29.  *  WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE.
  30.  *
  31.  */
  32.  
  33. /* Code in this file supports WSF functions: Query Reply,
  34.    normal 3270 data (calls writetm), file transfer (calls
  35.    vmxfer), and 3179 graphics.                                */
  36.  
  37. /* Reference manuals for graphics support:
  38.    IBM 3179 G Color Graphics Display Station Description,
  39.    GA18-2261
  40.    Reference Information for Picture Interchange Format,
  41.    SC33-0244  (part of IBM 3270 PC/G or PC/GX library)    
  42.  
  43.    General 3270 data stream information:
  44.    IBM 3270 Information Display System Data Stream
  45.    Programmer's Reference, GA23-0059 (revision -3 includes
  46.    some 3179 information)                                    */
  47.  
  48. /* Graphics has been tested using SAS version 5.16 with
  49.    device names of IBM3179 (SAS built-in support) and
  50.    GDDMPCGX (SAS calling GDDM Release 4).  Test plots include
  51.    the output from the GTESTIT procedure, the "cowboy hat"
  52.    sample, and the BITNET topology maps.                    */
  53.  
  54. #if !defined(USEDUMP)
  55.     #include "maclib.h"
  56.     #include "termdef.h"
  57.     #include "tn3270funcs.h"
  58.     #include "globals.h"
  59. #else
  60.     #pragma load "tn3270DumpFile"
  61. #endif
  62.  
  63. #pragma segment 3270wsf
  64.  
  65. #define    IAC    255        /* interpret as command: */
  66. #define EOR 239     /* end of record (transparent mode) */
  67.  
  68. #define adMax 37    /* Color QuickDraw arithmetic drawing max mode */
  69. #define adMin 39    /* Color QuickDraw arithmetic drawing min mode */
  70.  
  71.                             /* MacDraw PicComment codes we use */
  72. #define picDwgBeg        130
  73. #define picDwgEnd        131
  74. #define picGrpBeg        140
  75. #define picGrpEnd        141
  76.                             /* LaserWriter PicComment codes we use */
  77. #define SetLineWidth    182
  78.  
  79. extern struct Point sfppoint;
  80. extern RGBColor realblack, realwhite;
  81.  
  82. /* Code labelled "temp" is included to allow writing debugging data for
  83.    graphics support to a file.  Writing to the file is suppressed unless
  84.    "cf_dblevel" has been set by the main program.                            */
  85.  
  86. /*temp*/
  87. #include "stdio.h"
  88.  
  89.                             /* write structured field */
  90. void writesf(unsigned char *cmd,    /* command, starting with WSF op-code */
  91.              short len,                /* command length */
  92.              char init,                /* false = data continued from last call */
  93.              cnr *cp)
  94. {
  95. short currlen, curroff, fieldlen;
  96. unsigned char fieldid;
  97. char readflg;
  98.  
  99. if (!init) return;            /* currently, must get all data in one call */
  100. if (len < 1) return;
  101.  
  102. currlen = len - 1;            /* skip over wsf op-code */
  103. curroff = 1;
  104. while (currlen >= 3) {
  105.     fieldlen = cmd[curroff+1] + (cmd[curroff] << 8);
  106.     if (fieldlen == 0) fieldlen = currlen;
  107.     fieldid = cmd[curroff+2];
  108.     readflg = 0;
  109.     intwsf(fieldid, fieldlen, cmd+curroff, &readflg, cp);
  110.     if (readflg) break;        /* command was a read of some sort */
  111.     curroff += fieldlen;
  112.     currlen -= fieldlen;
  113.     }
  114. }
  115.  
  116.                              /* interpret one wsf field */
  117. void intwsf(unsigned char id,        /* wsf field type code */
  118.             short len,                /* length of data */
  119.             unsigned char *data,    /* data, starting with 2-byte length */
  120.             char *rdflag,            /* return 1 if read which generates response */
  121.             cnr *cp)
  122. { 
  123. /* temp */
  124. cp->wsfdbg.wsf_op = id;
  125. cp->wsfdbg.wsf_gr = cp->wsfdbg.grf_op = 0;
  126.  
  127. switch(id) {
  128.  
  129.     case 0x01:                        /* read partition */
  130.                 if (len < 5) break;
  131.                 if ((data[4] == 0x02) || (data[4] == 0x03))
  132.                     if (data[3] == 0xff) 
  133.                         wsfrpq(len, data, cp->newserver && (cp->cs.ext3270 == 0), cp);
  134.                 (*rdflag) = 1;
  135.                 break;
  136.  
  137.     case 0x03:                        /* erase/reset */
  138.                 if (data[3] & 0x80) {
  139.                     cp->ewamode = 1;        /* establish alternate screen size */
  140.                     }
  141.                 else {
  142.                     cp->ewamode = 0;        /* establish default screen size */
  143.                     }
  144.                 newmode(cp->ewamode, 0, cp);
  145.                 clrscn(cp);                /* clear text */
  146.                 cp->drawpict = 1;        /* force graphics clear */
  147.                 clrpict(cp);            /* clear graphics */
  148.                 break;
  149.  
  150.     case 0x06:                        /* load PS set */
  151.                 /* ignore command to clear PS storage */
  152.                 if ((len == 7) && (data[3] & 0x40)) break;
  153.                 /* real PS load not supported */
  154.                 hexdump(data, len, cp); /*temp*/
  155.                 break;
  156.  
  157.     case 0x09:                        /* set reply mode */
  158.                 /* not supported */
  159.                 hexdump(data, len, cp); /*temp*/
  160.                 break;
  161.  
  162.     case 0x0c:                        /* create partition */
  163.                 /* not supported */
  164.                 hexdump(data, len, cp); /*temp*/
  165.                 break;
  166.  
  167.     case 0x0f:                        /* graphic something */
  168.                 if (cp->myWindow == 0) break;
  169.                 writegf(data, len, cp);
  170.                 break;
  171.  
  172.     case 0x20:                        /* file transfer */
  173.                 /* special field type made up for RMAC/WMAC transfer */
  174.                 if (len < 4) break;    /* at least one data byte */
  175.                 cp->rbuf = data+3;
  176.                 cp->rlen = len-3;
  177.                 cp->sbuf = cp->readbuff+6;
  178.                 vmxfer(cp);        /* process file transfer command */
  179.                 if (cp->slen == 0) break;    /* send response, if generated */
  180.                 (cp->readbuff)[0] = 0xd7;
  181.                 cp->slen += 1;
  182.                 (cp->readbuff)[5] = 0x88;
  183.                 cp->rbsize = cp->slen + 5;
  184.                 if (cp->tcpflg) {
  185.                     (cp->readbuff)[cp->rbsize++] = IAC;
  186.                     (cp->readbuff)[cp->rbsize++] = EOR;
  187.                     }
  188.                 senddata(1, cp);
  189.                 break;
  190.  
  191.     case 0x40:                        /* outbound 3270DS */
  192.                 if (len < 5) return;
  193.                 if (data[4] == 0x6f) {            /* EAU */
  194.                     funckey(10, 0, cp);            /* simulate CLEAR key pressed */
  195.                     cp->rdaid = 0x60;
  196.                     break;
  197.                     }
  198.                 if ((data[3] == 0) && (data[4] == 0xf5)) {
  199.                     cp->skipnewmode = 1;        /* EW with PID = 0 keeps mode */
  200.                     }
  201.                 cp->ldvoff = 0;                    /* normal 3270 data stream */
  202.                 writetm(data+4, len-4, 1, cp);    /* update 3270 buffers */
  203.                 cp->skipnewmode = 0;            /* reset special flag */
  204.                 invldscr(cp);                    /* display new contents */
  205.                 endwcc(cp);                        /* post-write WCC functions */
  206.                 break;
  207.     default:
  208.                 hexdump(data, len, cp); /*temp*/
  209.                 break;
  210.     }
  211. }
  212.                             /* Read Partition Query */ 
  213. void wsfrpq(short len, unsigned char *data, char shortrsp, cnr *cp)
  214. {
  215. short i, j, listlen, reqtype, t, typecount, wsflen;
  216. static unsigned char long_wsftypes[] = {    /* all WSFR resources */    
  217.     0x86, 0x87, 0x85, 0x81, 0xa6, 0x88, 0x80, 0x84, 0x96, 0x99,
  218.     0xa1, 0xa8, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0x00};
  219. static unsigned char long_wsflist[] = {     /* 0x01 if in default list */
  220.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01,
  221.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  222. static unsigned char short_wsftypes[] = {    /* all WSFR resources */    
  223.     0x85, 0x81, 0xa6, 0x80, 0xa1, 0x00};
  224. static unsigned char short_wsflist[] = {     /* 0x01 if in default list */
  225.     0x01, 0x01, 0x01, 0x01, 0x00};
  226. unsigned char *wsftypes, *wsflist;
  227.  
  228. if (shortrsp) {
  229.     wsftypes = short_wsftypes;
  230.     wsflist = short_wsflist;
  231.     }
  232. else {
  233.     wsftypes = long_wsftypes;
  234.     wsflist = long_wsflist;
  235.     }
  236.  
  237. switch (data[4]) {
  238.     case 0x02:                /* Query */
  239.             listlen = 0;
  240.             reqtype = 1;
  241.             break;
  242.     case 0x03:                /* Query List */
  243.             if (len < 6) return;
  244.             listlen = len - 6;
  245.             reqtype = (data[5] & 0xc0) >> 6;
  246.             if (reqtype == 3) return;
  247.             break;
  248.     default:
  249.             return;
  250.     }
  251. typecount = strlen(wsftypes);
  252. wsflen = 0;
  253. for (i=0; i < typecount; i++) {        /* loop through all possible responses;
  254.                                        include in response those requested */
  255.     t = wsftypes[i];                /* t = resource number */
  256.     if (reqtype == 2) {        /* all types */
  257.         wsfadd(t, &wsflen, shortrsp, cp);
  258.         if (t == 179) wsfadd(254, &wsflen, shortrsp, cp); /* 2nd port response */
  259.         continue;
  260.         }
  261.     if ((reqtype == 1) && (wsflist[i] != 0)) {  /* default types wanted */
  262.         wsfadd(t, &wsflen, shortrsp, cp);
  263.         if (t == 179) wsfadd(254, &wsflen, shortrsp, cp); /* 2nd port response */
  264.         continue;
  265.         }
  266.     if (listlen == 0) continue;        /* listed types wanted */
  267.     for (j=0; j < listlen; j++)
  268.         if (data[j+6] == t) {
  269.             wsfadd(t, &wsflen, shortrsp, cp);
  270.             if (t == 179) wsfadd(254, &wsflen, shortrsp, cp); /* 2nd port response */
  271.             break;
  272.             }
  273.     }
  274.                             /* return null response if no other */
  275. if (wsflen == 0) wsfadd(255, &wsflen, shortrsp, cp);    
  276. (cp->readbuff)[0] = 0xd7;    /* send the response, similarly to read modified */
  277. wsflen += 1;
  278. (cp->readbuff)[5] = 0x88;            /* AID code = 0x88 (structured field) */
  279. cp->rbsize = wsflen + 5;
  280. if (cp->tcpflg) {
  281.     cp->readbuff[cp->rbsize++] = IAC;
  282.     cp->readbuff[cp->rbsize++] = EOR;
  283.     }
  284. senddata(1, cp);
  285. }
  286.  
  287.                          /* add resource no. "num" to response */
  288. void wsfadd(short num, short *len, char shortrsp, cnr *cp)
  289. {
  290. unsigned char **rhandle;
  291. short rlen, rnum;
  292. void (*procptr)(void *resptr, cnr *cp);
  293. unsigned char rscbuff[64];
  294.  
  295. rnum = num;        /* default resource is argument */
  296.  
  297. switch(num) {
  298.     case 129:    procptr = def_ua;        /* usable area */
  299.                 break;
  300.     case 166:    procptr = def_ip;        /* implicit partition */
  301.                 break;
  302.     default:    procptr = 0;
  303.                 break;
  304.     }
  305.  
  306. if (cp->cs.altptsize == 12) {
  307.     switch(num) {
  308.         case 133:    rnum = 252;            /* character sets */
  309.                     break;
  310.         case 182:    rnum = 250;            /* graphic symbol sets */
  311.                     break;
  312.         default:    break;
  313.         }
  314.     }
  315.  
  316. if (colormac && (!cp->cs.nocolor)) if (num == 134) rnum = 245;
  317. if (shortrsp) if (num == 128) rnum = 244;
  318.  
  319. if (cp->cs.simps) {                    /* include PS character set response */
  320.     if (rnum == 133) rnum = 251;
  321.     if (rnum == 252) rnum = 253;
  322.     }
  323.  
  324. rhandle = (unsigned char **)GetResource('WSFR', rnum);
  325. if (rhandle == 0) return;    /* should report error here */
  326. rlen = ((*rhandle)[0] << 8) + (*rhandle)[1];
  327.                     /* modify response which depends on screen format */
  328. if (procptr != 0) {
  329.     memcpy(rscbuff, (*rhandle), rlen);
  330.     (*procptr)(rscbuff, cp);
  331.     tcpmemcpy(cp->readbuff+6+(*len), rscbuff, &rlen, cp->tcpflg);
  332.     }
  333. else {
  334.     tcpmemcpy(cp->readbuff+6+(*len), (*rhandle), &rlen, cp->tcpflg);
  335.     }
  336. (*len) += rlen;
  337. }
  338.  
  339.                     /* modify usable area response for screen format */
  340. void def_ua(uareply *resptr, cnr *cp)
  341. {
  342. union {
  343.     unsigned short i;
  344.     unsigned char s[2];
  345.     } cvt;
  346.  
  347. resptr->w = 80;
  348. resptr->h = 24;
  349. switch (cp->cs.dfltptsize) {
  350.     case 12:
  351.             resptr->aw = 7;
  352.             resptr->ah = 16;
  353.             break;
  354.     default:
  355.             resptr->aw = 6;
  356.             resptr->ah = 12;
  357.             break;
  358.     }
  359.  
  360. cvt.i = cp->cs.altcols;
  361. memcpy(resptr->waua, cvt.s, 2);
  362. cvt.i = cp->cs.altrows;
  363. memcpy(resptr->haua, cvt.s, 2);
  364. switch (cp->cs.altptsize) {
  365.     case 12:
  366.             resptr->awaua = 7;
  367.             resptr->ahaua = 16;
  368.             break;
  369.     default:
  370.             resptr->awaua = 6;
  371.             resptr->ahaua = 12;
  372.             break;
  373.     }
  374. }
  375.     
  376.                     /* modify implicit partition response for screen format */
  377. void def_ip(ipreply *resptr, cnr *cp)
  378. {
  379. union {
  380.     unsigned short i;
  381.     unsigned char s[2];
  382.     } cvt;
  383.  
  384. cvt.i = 80;
  385. memcpy(resptr->wd, cvt.s, 2);
  386. cvt.i = 24;
  387. memcpy(resptr->hd, cvt.s, 2);
  388. cvt.i = cp->cs.altcols;
  389. memcpy(resptr->wa, cvt.s, 2);
  390. cvt.i = cp->cs.altrows;
  391. memcpy(resptr->ha, cvt.s, 2);
  392. switch (cp->cs.dfltptsize) {
  393.     case 12:
  394.             cvt.i = 7;
  395.             memcpy(resptr->wcd, cvt.s, 2);
  396.             cvt.i = 16;
  397.             memcpy(resptr->hcd, cvt.s, 2);
  398.             break;
  399.     default:
  400.             cvt.i = 6;
  401.             memcpy(resptr->wcd, cvt.s, 2);
  402.             cvt.i = 12;
  403.             memcpy(resptr->hcd, cvt.s, 2);
  404.             break;
  405.     }
  406. switch (cp->cs.altptsize) {
  407.     case 12:
  408.             cvt.i = 7;
  409.             memcpy(resptr->wca, cvt.s, 2);
  410.             cvt.i = 16;
  411.             memcpy(resptr->hca, cvt.s, 2);
  412.             break;
  413.     default:
  414.             cvt.i = 6;
  415.             memcpy(resptr->wca, cvt.s, 2);
  416.             cvt.i = 12;
  417.             memcpy(resptr->hca, cvt.s, 2);
  418.             break;
  419.     }
  420. }
  421.     
  422. void writegf(unsigned char *data, short len, cnr *cp)    /* graphic data stream */
  423. {
  424. short i;
  425.  
  426. cp->wsfdbg.wsf_gr = data[3];        /*temp*/
  427.  
  428. pictcp = cp;                        /* for saving graphics */
  429.  
  430. switch(data[3]) {
  431.     case 0x0f:                            /* graphic data */
  432.                 /* not supported */        /* controls inbound graphics data */
  433.                 hexdump(data+7, len-7, cp); /*temp*/
  434.                 break;
  435.     case 0x10:                            /* graphic picture */
  436.                 if (data[5] & 0x80) {
  437.                     cp->pleft = 0;                /* if first, reset count */
  438.                     initpict(cp);                /* maybe start of new picture */
  439.                     }
  440.                 if (len < 8) break;
  441.                 for (i=7; i < len; i++) grpparse(data[i], cp);
  442.                 if (data[5] & 0x40) showpict(cp);    /* if last, show result */
  443.                 break;
  444.     case 0x11:                            /* graphic control */
  445.                 if (data[5] & 0x80) {
  446.                     cp->cleft = 0;                /* if first, reset count */
  447.                     initpict(cp);                /* maybe start of new picture */
  448.                     }
  449.                 if (len < 8) break;
  450.                 for (i=7; i < len; i++) grcparse(data[i], cp);
  451.                 if (data[5] & 0x40) showpict(cp);    /* if last, show result */
  452.                 break;
  453.     case 0x1f:                            /* OEM data */
  454.                 /* not supported */
  455.                 hexdump(data+7, len-7, cp); /*temp*/
  456.                 break;
  457.  
  458.     default:    hexdump(data+7, len-7, cp);    /*temp*/
  459.                 break;
  460.     }
  461. }
  462.  
  463. void grpparse(unsigned char c, cnr *cp)        /* interpret graphic picture data */
  464. { 
  465. if (cp->pleft == 0) {
  466.     cp->pmode = cp->pcount = 0;
  467.     cp->pleft = 14;
  468.     }
  469.  
  470. switch (cp->pmode) {
  471.     case 0:                    /* processing segment header */
  472.             if (cp->pcount == 8) cp->ptemp1 = c;
  473.             if (cp->pcount == 9) cp->pleft = (cp->ptemp1 << 8) + c + 5;
  474.             if (cp->pcount == 13) {
  475.                     cp->pmode = 1;
  476.                     cp->pcount = 0;
  477.                     }
  478.             else cp->pcount++;
  479.             break;
  480.     case 1:                    /* processing order */
  481.             if (cp->pcount == 0) {
  482.                 cp->pboff = 0;
  483.                 (cp->pictbuff)[cp->pboff++] = c;
  484.                 if ((c==0x00) || (c==0x20) || (c==0xff)) {
  485.                     exdraw(cp->pictbuff, cp->pboff, cp);
  486.                     cp->pcount = 0;
  487.                     }
  488.                 else cp->pcount++;
  489.                 break;
  490.                 }
  491.             (cp->pictbuff)[cp->pboff++] = c;
  492.             if (cp->pcount == 1) {
  493.                 if ((((cp->pictbuff)[0] <= 0x7f) &&
  494.                       (((cp->pictbuff)[0] & 0x0f) >= 8)) || (c == 0)) {
  495.                     exdraw(cp->pictbuff, cp->pboff, cp);
  496.                     cp->pcount = 0;
  497.                     }
  498.                 else {
  499.                     cp->ptemp1 = c;        /* no. of operand bytes left */
  500.                     cp->pcount++;
  501.                     }
  502.                 break;
  503.                 }
  504.             cp->pcount++;
  505.             cp->ptemp1--;
  506.             if (cp->ptemp1 == 0) {
  507.                 exdraw(cp->pictbuff, cp->pboff, cp);
  508.                 cp->pcount = 0;
  509.                 }
  510.             break;
  511.     default:
  512.             break;
  513.     }
  514. cp->pleft--;
  515. }
  516.  
  517. void exdraw(unsigned char *opdata, short len, cnr *cp)    /* process drawing order */
  518. {
  519. short r, s;
  520. union {
  521.     short ipos;
  522.     unsigned char cpos[2];
  523.     } cvt;
  524. GrafPtr gp, dp;
  525. short newcolor;
  526. RGBColor rgbtemp;
  527. unsigned char imagebuff[258];
  528. unsigned char * imageptr;
  529. short imgoffset;
  530.  
  531. GetPort(&gp);
  532. if (cp->PictPtr != 0) {
  533.     SetPort(cp->PictPtr);
  534.     setgdev(cp);
  535.     }
  536. else {
  537.     SetPort(cp->myWindow);
  538.     }
  539. GetPort(&dp);
  540.  
  541. if (cf_dblevel == 3) {                /* dump all graphics if level 3 */
  542.     cp->wsfdbg.grf_op = opdata[0];    /* temp */
  543.     hexdump(opdata, len, cp);        /* temp */
  544.     }
  545.  
  546. switch(opdata[0]) {
  547.         case 0xa1:                    /* rel. line at current pos. */
  548.             r = opdata[1]/2;
  549.             s = 2;
  550.             MoveTo(sx(cp->xpos, cp), sy(cp->ypos, cp));
  551.             while (r > 0) {    
  552.                 cp->xpos += (char)opdata[s++];
  553.                 cp->ypos += (char)opdata[s++];
  554.                 myLineTo(sx(cp->xpos, cp), sy(cp->ypos, cp), cp);
  555.                 r --;
  556.                 }
  557.             break;
  558.         case 0x21:                    /* set current position */
  559.             cvt.cpos[0] = opdata[2];
  560.             cvt.cpos[1] = opdata[3];
  561.             cp->xpos = cvt.ipos;
  562.             cvt.cpos[0] = opdata[4];
  563.             cvt.cpos[1] = opdata[5];
  564.             cp->ypos = cvt.ipos;
  565.             break;
  566.         case 0x83:                    /* char. string at curr. pos. */
  567.             MoveTo(sx(cp->xpos, cp), sy(cp->ypos, cp)-2);
  568.             myDrawString(opdata+1, cp);
  569.             break;
  570.         case 0xc3:                    /* char. string at given pos. */
  571.             cvt.cpos[0] = opdata[2];
  572.             cvt.cpos[1] = opdata[3];
  573.             cp->xpos = cvt.ipos;
  574.             cvt.cpos[0] = opdata[4];
  575.             cvt.cpos[1] = opdata[5];
  576.             cp->ypos = cvt.ipos;
  577.             MoveTo(sx(cp->xpos, cp), sy(cp->ypos, cp));
  578.             opdata[5] = opdata[1] - 4;
  579.             if (opdata[5] < 0) opdata[5] = 0;
  580.             myDrawString(opdata+5, cp);
  581.             break;
  582.         case 0x85:                    /* fillet at current position */
  583.                 /* see comment below for fillet at given position */
  584.         case 0x81:                    /* line at current position */
  585.             r = opdata[1]/4;
  586.             s = 2;
  587.             MoveTo(sx(cp->xpos, cp), sy(cp->ypos, cp));
  588.             while (r > 0) {    
  589.                 cvt.cpos[0] = opdata[s++];
  590.                 cvt.cpos[1] = opdata[s++];
  591.                 cp->xpos = cvt.ipos;
  592.                 cvt.cpos[0] = opdata[s++];
  593.                 cvt.cpos[1] = opdata[s++];
  594.                 cp->ypos = cvt.ipos;
  595.                 myLineTo(sx(cp->xpos, cp), sy(cp->ypos, cp), cp);
  596.                 r --;
  597.                 }
  598.             break;
  599.         case 0xc5:                    /* fillet at given position */
  600.                 /* Too hard to do correctly for now, but at least    */
  601.                 /* draw the lines the curve should be tangent to,    */
  602.                 /* and update the current position.  Fillet has        */
  603.                 /* not been encountered in any test plots.            */
  604.         case 0xc1:                    /* line at given position */
  605.             cvt.cpos[0] = opdata[2];
  606.             cvt.cpos[1] = opdata[3];
  607.             cp->xpos = cvt.ipos;
  608.             cvt.cpos[0] = opdata[4];
  609.             cvt.cpos[1] = opdata[5];
  610.             cp->ypos = cvt.ipos;
  611.             MoveTo(sx(cp->xpos, cp), sy(cp->ypos, cp));
  612.             r = (opdata[1]-4)/4;
  613.             s = 6;
  614.             while (r > 0) {    
  615.                 cvt.cpos[0] = opdata[s++];
  616.                 cvt.cpos[1] = opdata[s++];
  617.                 cp->xpos = cvt.ipos;
  618.                 cvt.cpos[0] = opdata[s++];
  619.                 cvt.cpos[1] = opdata[s++];
  620.                 cp->ypos = cvt.ipos;
  621.                 myLineTo(sx(cp->xpos, cp), sy(cp->ypos, cp), cp);
  622.                 r --;
  623.                 }
  624.             break;
  625.         case 0xe1:                    /* relative line at given pos. */
  626.             cvt.cpos[0] = opdata[2];
  627.             cvt.cpos[1] = opdata[3];
  628.             cp->xpos = cvt.ipos;
  629.             cvt.cpos[0] = opdata[4];
  630.             cvt.cpos[1] = opdata[5];
  631.             cp->ypos = cvt.ipos;
  632.             MoveTo(sx(cp->xpos, cp), sy(cp->ypos, cp));
  633.             r = (opdata[1]-4)/2;
  634.             s = 6;
  635.             while (r > 0) {    
  636.                 cp->xpos += (char)opdata[s++];
  637.                 cp->ypos += (char)opdata[s++];
  638.                 myLineTo(sx(cp->xpos, cp), sy(cp->ypos, cp), cp);
  639.                 r --;
  640.                 }
  641.             break;
  642.         case 0xc7:                /* full arc at given position */
  643.                 /* Arcs are not supported yet, but at least move to    */
  644.                 /* the specified position.  Arc commands have not    */
  645.                 /* been encountered in any test plots.                */
  646.             cvt.cpos[0] = opdata[2];
  647.             cvt.cpos[1] = opdata[3];
  648.             cp->xpos = cvt.ipos;
  649.             cvt.cpos[0] = opdata[4];
  650.             cvt.cpos[1] = opdata[5];
  651.             cp->ypos = cvt.ipos;
  652.             break;
  653.         case 0x87:                /* full arc at current position */
  654.                 /* doesn't affect current position */
  655.         case 0x22:                /* set arc parameters */
  656.             break;
  657.         case 0x26:                /* set extended color */
  658.             setrgb(&newcolor, opdata[3], cp);
  659.             if (colormac && (!cp->cs.nocolor)) {
  660.                 GetEntryColor(cp->myPalette, newcolor, &rgbtemp);
  661.                 RGBForeColor(&rgbtemp);        /* set foreground drawing color */
  662.                 }
  663.             else {
  664.                 if (newcolor == RGBblack) {
  665.                     ForeColor(whiteColor);
  666.                     }
  667.                 else {
  668.                     ForeColor(blackColor);
  669.                     }
  670.                 }
  671.             break;
  672.         case 0x0a:                /* set color */
  673.             setrgb(&newcolor, opdata[1], cp);
  674.             if (colormac && (!cp->cs.nocolor)) {
  675.                 GetEntryColor(cp->myPalette, newcolor, &rgbtemp);
  676.                 RGBForeColor(&rgbtemp);        /* set foreground drawing color */
  677.                 }
  678.             else {
  679.                 if (newcolor == RGBblack) {
  680.                     ForeColor(whiteColor);
  681.                     }
  682.                 else {
  683.                     ForeColor(blackColor);
  684.                     }
  685.                 }
  686.             break;
  687.         case 0x68:                /* begin area */
  688.             cp->mypoly = OpenPoly();    /* create new polygon */
  689.             cp->aflags = opdata[1];        /* save flag bits */
  690.             cp->area_active = 1;        /* remeber area is active */
  691.             break;
  692.         case 0x60:                /* end area */
  693.             if (cp->area_active == 0) {    /* check for datastream error */
  694.                 break;
  695.                 }
  696.             ClosePoly();            /* done saving stuff */
  697.             PenPat(&(cp->fillpat));        /* set fill pattern */
  698.             PaintPoly(cp->mypoly);        /* draw it */
  699.             PenPat(&qd.black);        /* restore default pattern */
  700.             if (cp->aflags & 0x40) FramePoly(cp->mypoly);  /* handle outline */
  701.             KillPoly(cp->mypoly);        /* dispose of it */
  702.             cp->area_active = 0;        /* reset active flag */
  703.             break;
  704.         case 0x28:                /* set pattern symbol (area fill pattern) */
  705.             setpat(&(cp->fillpat), opdata[1], cp);
  706.             break;
  707.         case 0x29:                /* set marker symbol */
  708.             setmark(&(cp->markchar), opdata[1], cp);
  709.             break;
  710.         case 0xc2:                /* marker at given position */
  711.         case 0x82:                /* marker at current position */
  712.             r = opdata[1]/4;
  713.             s = 2;
  714.             while (r > 0) {    
  715.                 cvt.cpos[0] = opdata[s++];
  716.                 cvt.cpos[1] = opdata[s++];
  717.                 cp->xpos = cvt.ipos;
  718.                 cvt.cpos[0] = opdata[s++];
  719.                 cvt.cpos[1] = opdata[s++];
  720.                 cp->ypos = cvt.ipos;
  721.                 MoveTo(sx(cp->xpos, cp), sy(cp->ypos, cp)+4);
  722.                 (cp->markstr)[1] = cp->markchar;        /* make 1-character Pascal string */
  723.                 myDrawString(cp->markstr, cp);
  724.                 r --;
  725.                 }
  726.             break;
  727.         case 0x18:                /* set line type */
  728.             if (opdata[1] == 0) cp->linet = cp->dfltlt;
  729.             else cp->linet = opdata[1];
  730.             break;
  731.         case 0x19:                /* set line width */
  732.             if (opdata[1] == 0) cp->linew = cp->dfltlw;
  733.             else cp->linew = opdata[1];
  734.             break;
  735.         case 0xd1:                /* begin image */
  736.         case 0x91:                /* begin image at current position */
  737.             cp->image_srcRect.top = 0;
  738.             cp->image_srcRect.left = 0;
  739.             cp->image_srcRect.bottom = 1;
  740.             if (opdata[0] == 0xd1) {
  741.                 /* ignore if not in the format we expect*/
  742.                 if (opdata[1] != 10) break;
  743.                 if (opdata[6] != 0) break;
  744.                 if (opdata[7] != 0) break;
  745.                 /* define upper left corner of bitmap */
  746.                 cvt.cpos[0] = opdata[2];
  747.                 cvt.cpos[1] = opdata[3];
  748.                 cp->image_dstRect.left = sx(cvt.ipos, cp);
  749.                 cvt.cpos[0] = opdata[4];
  750.                 cvt.cpos[1] = opdata[5];
  751.                 cp->image_dstRect.top = sy(cvt.ipos, cp);
  752.                 imgoffset = 8;
  753.                 }
  754.             else {
  755.                 /* ignore if not in the format we expect*/
  756.                 if (opdata[1] != 6) break;
  757.                 if (opdata[2] != 0) break;
  758.                 if (opdata[3] != 0) break;
  759.                 /* define upper left corner of bitmap */
  760.                 cp->image_dstRect.left = sx(cp->xpos, cp);
  761.                 cp->image_dstRect.top = sy(cp->ypos, cp);
  762.                 imgoffset = 4;
  763.                 }
  764.             cp->image_dstRect.bottom = cp->image_dstRect.top + 1;
  765.             /* convert width */
  766.             cvt.cpos[0] = opdata[imgoffset];
  767.             cvt.cpos[1] = opdata[imgoffset+1];
  768.             cp->image_srcRect.right = cvt.ipos;
  769.             cp->image_dstRect.right = cp->image_dstRect.left + cvt.ipos;
  770.             cp->image_srcBits.rowBytes = (cvt.ipos+7)/8;
  771.             if (cp->image_srcBits.rowBytes%2) cp->image_srcBits.rowBytes++;
  772.             /* convert height */
  773.             cvt.cpos[0] = opdata[imgoffset+2];
  774.             cvt.cpos[1] = opdata[imgoffset+3];
  775.             cp->image_rowcount = cvt.ipos;
  776.             cp->image_srcBits.bounds = cp->image_srcRect;
  777.             if (cp->pictopen) {
  778.                 if (cp->image_dstRect.top < cp->ymin) cp->ymin = cp->image_dstRect.top;
  779.                 if (cp->image_dstRect.top > cp->ymax) cp->ymax = cp->image_dstRect.top;
  780.                 if (cp->image_dstRect.bottom < cp->ymin) cp->ymin = cp->image_dstRect.bottom;
  781.                 if (cp->image_dstRect.bottom > cp->ymax) cp->ymax = cp->image_dstRect.bottom;
  782.                 if (cp->image_dstRect.left < cp->xmin) cp->xmin = cp->image_dstRect.left;
  783.                 if (cp->image_dstRect.left > cp->xmax) cp->xmax = cp->image_dstRect.left;
  784.                 if (cp->image_dstRect.right < cp->xmin) cp->xmin = cp->image_dstRect.right;
  785.                 if (cp->image_dstRect.right > cp->xmax) cp->xmax = cp->image_dstRect.right;
  786.                 }
  787.             cp->image_active = 1;
  788.             break;
  789.         case 0x92:                /* image data */
  790.             if (cp->image_active == 0) break;
  791.             if (cp->image_rowcount == 0) break;
  792.             cp->image_rowcount--;
  793.             imageptr = imagebuff;
  794.             if (((long)imageptr)%2) imageptr++;
  795.             memcpy(imageptr, opdata+2, opdata[1]);
  796.             cp->image_srcBits.baseAddr = imageptr;
  797.             if (colormac && (!cp->cs.nocolor)) {
  798.                 GetBackColor(&rgbtemp);
  799.                 if (cp->cs.invertbw) { 
  800.                     RGBBackColor(&realwhite);
  801.                     }
  802.                 else {
  803.                     RGBBackColor(&realblack);
  804.                     }
  805.                 CopyBits(&(cp->image_srcBits), &(dp->portBits),
  806.                     &(cp->image_srcRect), &(cp->image_dstRect), cp->copymode, 0L);
  807.                 RGBBackColor(&rgbtemp);
  808.                 }
  809.             else {
  810.                 CopyBits(&(cp->image_srcBits), &(dp->portBits),
  811.                     &(cp->image_srcRect), &(cp->image_dstRect), cp->copymode, 0L);
  812.                 }
  813.             cp->image_dstRect.top++;
  814.             cp->image_dstRect.bottom++;
  815.             break;
  816.         case 0x93:                /* end image */
  817.             if (cp->image_active == 0) break;
  818.             cp->image_active = 0;
  819.             break;
  820.         case 0x0c:                /* set foreground mix */
  821.             setmixmode(opdata[1], cp);
  822.             break;
  823.         /* The following are not easily implemented using QuickDraw; */
  824.         /* none of these appear to be needed for the test plots to     */
  825.         /* display correctly:                                           */
  826.         case 0x33:                /* set character cell */
  827.         case 0x34:                /* set character angle */
  828.         case 0x35:                /* set character shear */
  829.         case 0x38:                /* set character set */
  830.         case 0x3a:                /* set character direction */
  831.         case 0x37:                /* set marker cell */
  832.         case 0xff:                /* end of symbol definition */
  833.         /* The following are documented by IBM to be ignored in    files    */
  834.         /* imported into GGXA, and are unlikely to be used.  None of    */
  835.         /* of the test plots need them.                                    */
  836.         case 0x0d:                /* set background mix */
  837.             /* no-op for 3179 */
  838.         case 0x39:                /* set character precision */
  839.         case 0x3b:                /* set marker precision */
  840.         case 0x3c:                /* set marker set */
  841.         case 0x08:                /* set pattern set */
  842.         case 0x43:                /* set pick identifier */
  843.         case 0x04:                /* segment characteristics */
  844.         case 0x3e:                /* end prologue */
  845.         case 0x71:                /* end segment */
  846.         /* these do nothing by definition */
  847.         case 0x01:                /* comment */
  848.         case 0x00:                /* no-op */
  849.             break;
  850.         default:
  851.             if (cf_dblevel == 3) break;    /* for level 3, already dumped */
  852.             cp->wsfdbg.grf_op = opdata[0];    /* temp */
  853.             hexdump(opdata, len, cp);        /* temp */
  854.             break;
  855.         }
  856.  
  857. if (cp->PictPtr != 0) resetgdev();
  858. SetPort(gp);
  859. }
  860.  
  861. void grcparse(unsigned char c, cnr *cp)
  862. {
  863. if (cp->cleft == 0) {
  864.     cp->cmode = cp->ccount = 0;
  865.     cp->cleft = 12;
  866.     }
  867.  
  868. switch (cp->cmode) {
  869.     case 0:            /* processing procedure header */
  870.         if (cp->ccount == 8) cp->ctemp1 = c;
  871.         if (cp->ccount == 9) cp->cleft = (cp->ctemp1 << 8) + c + 3;
  872.         if (cp->ccount == 11) {
  873.             cp->cmode = 1;
  874.             cp->ccount = 0;
  875.             }
  876.         else cp->ccount++;
  877.         break;
  878.     case 1:            /* processing procedural instruction */
  879.         if (cp->ccount == 0) {
  880.             cp->cboff = 0;
  881.             (cp->ctlbuff)[cp->cboff++] = c;
  882.             if (c == 0x00) {
  883.                 exctl(cp->ctlbuff, cp->cboff, cp);
  884.                 cp->ccount = 0;
  885.                 }
  886.             else cp->ccount++;
  887.             break;
  888.             }
  889.         (cp->ctlbuff)[cp->cboff++] = c;
  890.         if (cp->ccount == 1) {
  891.             if (((cp->ctlbuff)[0] >= 0x08) && ((cp->ctlbuff)[0] <= 0x0f)) {
  892.                 exctl(cp->ctlbuff, cp->cboff, cp);
  893.                 cp->ccount = 0;
  894.                 }
  895.             else {
  896.                 cp->ctemp1 = c;        /* no. of operand bytes left */
  897.                 cp->ccount++;
  898.                 }
  899.             break;
  900.             }
  901.         cp->ccount++;
  902.         cp->ctemp1--;
  903.         if (cp->ctemp1 == 0) {
  904.             exctl(cp->ctlbuff, cp->cboff, cp);
  905.             cp->ccount = 0;
  906.             }
  907.         break;
  908.     default:
  909.         break;
  910.     }
  911. cp->cleft--;
  912. }
  913.  
  914. void exctl(unsigned char *opdata, short len, cnr *cp)    /* process control command */
  915. {
  916. GrafPtr gp;
  917. char setdflt;
  918. short i;
  919.  
  920. GetPort(&gp);
  921. if (cp->PictPtr != 0) {
  922.     SetPort(cp->PictPtr);
  923.     setgdev(cp);
  924.     }
  925. else SetPort(cp->myWindow);
  926.  
  927. if (cf_dblevel == 3) {            /* for level 3, dump all graphics */
  928.     cp->wsfdbg.grf_op = opdata[0];    /* temp */
  929.     hexdump(opdata, len, cp);        /* temp */
  930.     }
  931.  
  932. switch(opdata[0]) {
  933.     case 0x0a:                    /* erase graphics space */
  934.         clrpict(cp);
  935.         break;
  936.     case 0x00:                    /* no operation */
  937.     case 0x01:                    /* comment */
  938.     case 0x0f:                    /* stop draw */  /* no-op for 3179 */
  939.         break;
  940.     case 0x21:                    /* set current defaults */
  941.                 /* untested- not used by test plots */
  942.         setdflt = (opdata[5] & 0x80) == 0;
  943.         switch(opdata[2]) {            /* SET code */
  944.             case 0x00:                    /* drawing attributes */
  945.                 i = 6;                        /* offset for next data byte */
  946.                 if (opdata[3] & 0x80) {     /* color specified */
  947.                     if (setdflt) cp->dfltcolor = 4;        /* green */
  948.                     else cp->dfltcolor = opdata[i+1];
  949.                     i += 2;
  950.                     }
  951.                 if (opdata[3] & 0x20) {        /* foreground mix specified */
  952.                     if (setdflt) cp->dfltmix = 2;        /* overpaint */
  953.                     else cp->dfltmix = opdata[i];
  954.                     i++;
  955.                     }    
  956.                 break;
  957.             case 0x01:                    /* line attributes */
  958.                 i = 6;                        /* offset for next data byte */
  959.                 if (opdata[3] & 0x80) {        /* line type specified */
  960.                     if (setdflt) cp->dfltlt = 7;    /* default is solid line */
  961.                     else cp->dfltlt = opdata[i];
  962.                     i++;
  963.                     }
  964.                 if (opdata[3] & 0x40)        /* line width specified */
  965.                     if (setdflt) cp->dfltlw = 1;    /* default is 1 pixel wide */
  966.                     else cp->dfltlw = opdata[i];
  967.                 break;
  968.             case 0x02:                    /* character attributes */
  969.                 break;                        /* not supported */
  970.             case 0x03:                    /* marker attributes */
  971.                 i = 6;                        /* offset for next data byte */
  972.                 if (opdata[3] & 0x40)        /* cellsize */
  973.                     i += 4;
  974.                 if (opdata[3] & 0x10)        /* precision */
  975.                     i += 1;
  976.                 if (opdata[3] & 0x08)        /* symbol set */
  977.                     i += 1;
  978.                 if (opdata[3] & 0x01)        /* marker symbol */
  979.                     if (setdflt) cp->dfltmarker = 0xb5;        /* diamond */
  980.                     else setmark(&(cp->dfltmarker), opdata[i], cp);
  981.                 break;
  982.             case 0x04:                    /* pattern attributes */
  983.                 i = 6;                        /* offset for next data byte */
  984.                 if (opdata[3] & 0x08)        /* symbol set */
  985.                     i += 1;
  986.                 if (opdata[3] & 0x01)        /* pattern symbol */
  987.                     if (setdflt) setpat(&(cp->dfltpat), 16, cp);
  988.                     else setpat(&(cp->dfltpat), opdata[i], cp);
  989.                 break;
  990.             case 0x0b:                    /* arc parameters */
  991.                 break;                        /* not supported */
  992.             default:                    /* reserved; SAS & GDDM use 0x05, 0x07 */
  993.                 if (cf_dblevel == 3) break;    /* for level 3, dumped already */        
  994.                 cp->wsfdbg.grf_op = opdata[0];        /* temp */
  995.                 hexdump(opdata, len, cp);            /* temp */
  996.                 break;
  997.             }
  998.         break;
  999.         /* no support for the graphics cursor */
  1000.     case 0x08:                    /* attach graphic cursor */
  1001.     case 0x09:                    /* detach graphic cursor */
  1002.     case 0x31:                    /* set graphic cursor pos. */
  1003.         break;
  1004.     default:
  1005.         if (cf_dblevel == 3) break;    /* for level 3, dumped already */        
  1006.         cp->wsfdbg.grf_op = opdata[0];        /* temp */
  1007.         hexdump(opdata, len, cp);            /* temp */
  1008.         break;
  1009.     }
  1010.  
  1011. if (cp->PictPtr != 0) resetgdev();
  1012. SetPort(gp);
  1013. }
  1014.  
  1015. void clrpict(cnr *cp)        /* erase graphics space */
  1016. {
  1017. GrafPtr gp;
  1018. RGBColor rgbtemp;
  1019. static unsigned char endarea[] = {0x60, 0};
  1020. static unsigned char endimage[] = {0x93, 0};
  1021.  
  1022. cp->pndclr = 0;                            /* reset pending clear */
  1023. if (cp->drawpict == 0) return;            /* nothing to do if no graphics */
  1024. if (cp->area_active) {                    /* end area if still active */
  1025.     exdraw(endarea, 2, cp);                /* execute end area command */
  1026.     }
  1027. if (cp->image_active) {                    /* end image if still active */
  1028.     exdraw(endimage, 2, cp);            /* execute end image command */
  1029.     }
  1030. if (cp->pictopen) {                        /* close PICT file if open */
  1031.     closepictfile(cp);
  1032.     }
  1033. GetPort(&gp);                        /* save current GrafPort */
  1034. if (cp->PictPtr == 0) {                /* erase port we draw in */
  1035.     SetPort(cp->myWindow);
  1036.     EraseRect(&((cp->myWindow)->portRect));
  1037.     setmixmode(0, cp);                /* set default pen mode */
  1038.     }
  1039. else {
  1040.     SetPort(cp->PictPtr);
  1041.     setgdev(cp);
  1042.     EraseRect(&(cp->PictPort.portRect));
  1043.     setmixmode(0, cp);
  1044.     resetgdev();
  1045.     }
  1046. if (colormac && (!cp->cs.nocolor)) {
  1047.     SetPort(cp->WritePtr);            /* restore background color */
  1048.     if (cp->textmap) setgdev(cp);
  1049.     GetEntryColor(cp->myPalette, RGBback, &rgbtemp);
  1050.     RGBBackColor(&rgbtemp);
  1051.     if (cp->textmap) resetgdev();
  1052.     }
  1053. SetPort(gp);                        /* restore GrafPort */
  1054. cp->drawpict = 0;                    /* don't show graphics any more */
  1055. cp->newpict = 1;                    /* next order starts new picture */
  1056. if (cp->pendalign) {                /* align bitmaps if changed during display */
  1057.     alignbitmaps(cp);
  1058.     newstat(cp);
  1059.     }
  1060. invldscr(cp);                        /* force screen to be redrawn */
  1061.                                     /* end saving PICT file */
  1062. }
  1063.  
  1064. void initpict(cnr *cp)        /* initialize at start of new picture */
  1065. {
  1066. if (!(cp->newpict)) return;
  1067. cp->drawpict = 1;        /* clear initial screen */
  1068. clrpict(cp);            /* (resets drawpict, sets newpict) */
  1069. cp->newpict = 0;        /* no longer new picture */
  1070.                         /* begin saving PICT file */
  1071. if (cp->savepict && (cp->PictPtr != 0)) {
  1072.     openpictfile(cp);
  1073.     }
  1074. }
  1075.  
  1076. void showpict(cnr *cp)        /* cause graphics data to be displayed */
  1077. {
  1078. GrafPtr gp;
  1079. RGBColor rgbtemp;
  1080.  
  1081. cp->drawpict = 1;                    /* include graphics in screen updates */
  1082. if (colormac && (!cp->cs.nocolor)) {                        /* change text background to black or white */
  1083.     GetPort(&gp);
  1084.     SetPort(cp->WritePtr);
  1085.     if (cp->textmap) setgdev(cp);
  1086.     if (cp->cs.invertbw) GetEntryColor(cp->myPalette, RGBwhite, &rgbtemp);
  1087.              else GetEntryColor(cp->myPalette, RGBblack, &rgbtemp);
  1088.     RGBBackColor(&rgbtemp);
  1089.     SetPort(gp);
  1090.     if (cp->textmap) resetgdev();
  1091.     }
  1092. invldscr(cp);                        /* invalidate screen to force update */
  1093. }
  1094.  
  1095. /* The following two function are simple now, since tn3270's response to
  1096.    WSF Query Reply now accurately describes the Mac screen dimensions.    
  1097.    Both SAS and GDDM adapt to this very well.                            */
  1098.  
  1099. short sx(short x, cnr *cp)        /* convert data stream x-coordinate to Mac coordinate */
  1100. {
  1101. register short r;
  1102.  
  1103. /* if (PictPtr == 0) {
  1104.     if (cur_ptsize == 12) r = x + 286;
  1105.     else r = x + 246;
  1106.     }
  1107. else {
  1108.     if (cur_ptsize == 12) r = x + 318;
  1109.     else r = x + 255;
  1110.     }    */
  1111. r = x + cp->hpixsize/2;
  1112. if (cp->PictPtr == 0) {
  1113.     r += cp->textRect.left;
  1114.     }
  1115. if (cp->pictopen) {
  1116.     if (r < cp->xmin) cp->xmin = r;
  1117.     if (r > cp->xmax) cp->xmax = r;
  1118.     }
  1119. return(r);
  1120. }
  1121.  
  1122. short sy(short y, cnr *cp)        /* convert data stream y-coordinate to Mac coordinate */
  1123. {
  1124. register short r;
  1125.  
  1126. /* if (PictPtr == 0) {
  1127.     if ((cur_ptsize == 9) && (cur_rows == 24)) r = 139 - y;
  1128.     else r = 188 - y;
  1129.     }
  1130. else {
  1131.     if ((cur_ptsize == 9) && (cur_rows == 24)) r = 146 - y;
  1132.     else r = 195 - y;
  1133.     } */
  1134.     
  1135. r = (cp->vpixsize - 19)/2 - y;
  1136. if (cp->PictPtr == 0) {
  1137.     r += cp->textRect.top;
  1138.     }
  1139. if (cp->pictopen) {
  1140.     if (r < cp->ymin) cp->ymin = r;
  1141.     if (r > cp->ymax) cp->ymax = r;
  1142.     }
  1143. return(r);
  1144. }
  1145.  
  1146. void myLineTo(short x, short y, cnr *cp)
  1147. {
  1148. switch (cp->linet) {    /* set pen pattern for line type */
  1149.     case 8:                /* invisible */
  1150.             PenPat(&qd.white);
  1151.             break;
  1152.     default:            /* all other, until I figure out how to do this */
  1153.             PenPat(&qd.black);
  1154.             break;
  1155.     }
  1156.                     /* set pen width as requested */
  1157. if (cp->linew == 0) PenSize(1, 1);
  1158. else PenSize(cp->linew, cp->linew);
  1159. LineTo(x, y);        /* draw the line */
  1160. PenPat(&qd.black);    /* restore QuickDraw defaults */
  1161. PenSize(1, 1);
  1162. }
  1163.  
  1164. void myDrawString(unsigned char *s, cnr *cp)
  1165.                             /* s is a Pascal string */
  1166. {
  1167. short i;
  1168. unsigned char xlstr[256];    /* translated copy of string */
  1169. Point penloc;
  1170. short texttop, textleft, textbottom, textright;
  1171. FontInfo fi;
  1172.  
  1173. if (s[0] == 0) return;        /* just return if null string */
  1174. xlstr[0] = s[0];            /* copy the string */
  1175. memcpy(xlstr+1, s+1, s[0]);
  1176.  
  1177. if (cp->nl_handle != 0) {
  1178.     for (i=1; i <= xlstr[0]; i++)        /* translate EBCDIC for language */
  1179.         xlstr[i] = (cp->nltab)[xlstr[i]];
  1180.     }
  1181.  
  1182. if (cp->pictopen && (xtabh != 0)) {
  1183.     for (i=1; i <= xlstr[0]; i++)        /* translate string to ASCII */
  1184.         xlstr[i] = (*xtabh)[xlstr[i]];
  1185.     }
  1186. if (cp->pictopen) {
  1187.     GetPen(&penloc);
  1188.     textleft = penloc.h;
  1189.     GetFontInfo(&fi);
  1190.     texttop = penloc.v + fi.ascent;
  1191.     textbottom = penloc.v - fi.descent - fi.leading;
  1192.     }
  1193. DrawString(xlstr);
  1194. if (cp->pictopen) {
  1195.     GetPen(&penloc);
  1196.     textright = penloc.h;
  1197.     if (texttop > cp->ymax) cp->ymax = texttop;
  1198.     if (texttop < cp->ymin) cp->ymin = texttop;
  1199.     if (textbottom > cp->ymax) cp->ymax = textbottom;
  1200.     if (textbottom < cp->ymin) cp->ymin = textbottom;
  1201.     if (textleft < cp->xmin) cp->xmin = textleft;
  1202.     if (textleft > cp->xmax) cp->xmax = textleft;
  1203.     if (textright < cp->xmin) cp->xmin = textright;
  1204.     if (textright > cp->xmax) cp->xmax = textright;
  1205.     }
  1206. }
  1207.  
  1208.                         /* set newcolor from data stream code */
  1209. void setrgb(short *newcolor, unsigned char code, cnr *cp)
  1210. {
  1211. if ((code == 0) || (code == 16)) code = cp->dfltcolor;
  1212.  
  1213. switch(code) {
  1214.     case 1:                /* blue */
  1215.     case 9:                /* dark blue */
  1216.         (*newcolor) = RGBblue;
  1217.         break;
  1218.     case 2:                /* red */
  1219.     case 10:            /* orange */
  1220.         (*newcolor) = RGBred;
  1221.         break;
  1222.     case 3:                /* pink */
  1223.     case 11:            /* purple */
  1224.         (*newcolor) = RGBpink;
  1225.         break;
  1226.     case 4:                /* green */
  1227.     case 12:            /* dark green */
  1228.         (*newcolor) = RGBgreen;
  1229.         break;
  1230.     case 5:                /* turquoise */
  1231.     case 13:            /* dark turquoise */
  1232.         (*newcolor) = RGBturquoise;
  1233.         break;
  1234.     case 6:                /* yellow */
  1235.     case 14:            /* mustard */
  1236.         (*newcolor) = RGByellow;
  1237.         break;
  1238.     case 7:                /* neutral */
  1239.     case 15:            /* gray */
  1240.         if (cp->cs.invertbw) (*newcolor) = RGBblack;
  1241.         else (*newcolor) = RGBwhite;
  1242.         break;
  1243.     case 8:                /* background */
  1244.         if (cp->cs.invertbw) (*newcolor) = RGBwhite;
  1245.         else (*newcolor) = RGBblack;
  1246.         break;
  1247.     default:
  1248.         if (cp->cs.invertbw) (*newcolor) = RGBblack;
  1249.         else (*newcolor) = RGBwhite;
  1250.         break;
  1251.     }
  1252. }
  1253.  
  1254.                             /* convert marker code to character */
  1255. void setmark(unsigned char *mark, unsigned char code, cnr *cp)        
  1256. {
  1257. switch(code) {
  1258.     case 0x00:            /* default */
  1259.         (*mark) = cp->dfltmarker;
  1260.         break;
  1261.     case 0x01:            /* cross */
  1262.         (*mark) = 0x46;    /* sort of a cross */
  1263.         break;
  1264.     case 0x02:            /* plus */
  1265.         (*mark) = 0x4e;    /* normal plus */
  1266.         break;
  1267.     case 0x05:            /* 6-point star */
  1268.     case 0x06:            /* 8-point star */
  1269.         (*mark) = 0x5c;    /* normal asterisk */
  1270.         break;
  1271.     default:
  1272.         (*mark) = 0xb5;    /* solid diamond */
  1273.         break;
  1274.     }
  1275. }
  1276.  
  1277.                         /* define pattern from code */
  1278. void setpat(PatPtr pat, unsigned char code, cnr *cp)        
  1279. {
  1280. static Pattern pattab[16] = {
  1281.     {0xdd, 0xff, 0x77, 0xff, 0xdd, 0xff, 0x77, 0xff},    /* 87.5% gray */
  1282.     {0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77},    /* 75% gray */
  1283.     {0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55},    /* 50% gray */
  1284.     {0xaa, 0x00, 0x55, 0x00, 0xaa, 0x00, 0x55, 0x00},    /* 25% gray */
  1285.     {0x88, 0x00, 0x22, 0x00, 0x88, 0x00, 0x22, 0x00},    /* 12.5% gray */
  1286.     {0x80, 0x00, 0x08, 0x00, 0x80, 0x00, 0x08, 0x00},    /* 6.25% gray */
  1287.     {0x80, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00},    /* 3.125% gray */
  1288.     {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},    /* 1.5625% gray */
  1289.     {0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88},    /* vertical lines */
  1290.     {0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00},    /* horizontal lines */
  1291.     {0x11, 0x11, 0x22, 0x22, 0x44, 0x44, 0x88, 0x88},    /* "/" diags, less steep */
  1292.     {0x11, 0x22, 0x44, 0x88, 0x11, 0x22, 0x44, 0x88},    /* "/" diags., 45 degrees */
  1293.     {0x88, 0x88, 0x44, 0x44, 0x22, 0x22, 0x11, 0x11},    /* "\" diags., less steep */
  1294.     {0x88, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x11},    /* "\" diags., 45 degrees */
  1295.     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},    /* white (none) */
  1296.     {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}};    /* black (solid) */    
  1297.  
  1298. if (code == 0) memcpy(pat, &(cp->dfltpat), 8);
  1299. else {
  1300.     if (code > 16) code = 16;
  1301.     memcpy(pat, &(pattab[code-1]), 8);
  1302.     }
  1303. }
  1304.  
  1305. void setmixmode(short mode, cnr *cp)
  1306. {
  1307. if (mode == 0) mode = cp->dfltmix;
  1308. switch(mode) {
  1309.     case 1:                /* "mix" colors */
  1310.             if (colormac && (!cp->cs.nocolor)) {
  1311.                 if (cp->cs.invertbw) {
  1312.                     PenMode(adMin);
  1313.                     cp->copymode = adMin;
  1314.                     }
  1315.                 else {
  1316.                     PenMode(adMax);
  1317.                     cp->copymode = adMax;
  1318.                     }
  1319.                 }
  1320.             else {
  1321.                 PenMode(patOr);
  1322.                 cp->copymode = srcOr;
  1323.                 }
  1324.             break;
  1325.     default:            /* overpaint */
  1326.             PenMode(patCopy);
  1327.             cp->copymode = srcCopy;
  1328.             break;
  1329.     }
  1330. }
  1331.  
  1332. void openpictfile(cnr *cp)
  1333. {
  1334. Point where;
  1335. DlgHookProcPtr dlgHook;
  1336. SFReply reply;
  1337. OSErr rc;
  1338. short i;
  1339. long longzero = 0;
  1340. long iocount;
  1341. GrafPtr gp;
  1342.  
  1343. where = sfppoint;
  1344. dlgHook = 0;
  1345. arrowcursor();
  1346. SFPutFile(where, "\pSave graphics in:",
  1347.           cp->pict_fName, dlgHook, &reply);
  1348. if (reply.good == 0) return;
  1349. (cp->pict_fName)[0] = reply.fName[0];                /* save filename */
  1350. memcpy(cp->pict_fName+1, reply.fName+1, reply.fName[0]);
  1351. rc = FSDelete(&reply.fName, reply.vRefNum);    /* delete existing file */
  1352. if ((rc != 0) && (rc != -43)) {        /* file not found is ok */
  1353.     stoperr(wpictalrt, cp);
  1354.     return;
  1355.     }
  1356. rc = Create(&reply.fName, reply.vRefNum, 'MDRW', 'PICT');
  1357. if (rc != 0) {
  1358.     stoperr(wpictalrt, cp);
  1359.     return;
  1360.     }
  1361. rc = FSOpen(&reply.fName, reply.vRefNum, &(cp->pictfref));
  1362. if (rc != 0) {
  1363.     stoperr(wpictalrt, cp);
  1364.     return;
  1365.     }
  1366.                                 /* write 512-byte header */
  1367. for (i=0; i < 512/4; i++) {
  1368.     iocount = 4;
  1369.     rc = FSWrite(cp->pictfref, &iocount, &longzero);
  1370.     if (rc != 0) break;
  1371.     }
  1372.                                 /* write fixed fields of PICT */
  1373. if (rc == 0) {
  1374.     for (i=0; i < (sizeof(short) + sizeof(Rect))/2; i++) {
  1375.         iocount = 2;
  1376.         rc = FSWrite(cp->pictfref, &iocount, &longzero);
  1377.         if (rc != 0) break;
  1378.         }
  1379.     }
  1380.     
  1381. if (rc != 0) {                    /* clean up if write error */
  1382.     FSClose(cp->pictfref);
  1383.     FSDelete(&reply.fName, reply.vRefNum);
  1384.     stoperr(wpictalrt, cp);
  1385.     return;
  1386.     }
  1387. cp->pictvref = reply.vRefNum;
  1388. cp->pictopen = 1;
  1389. cp->picterr = 0;
  1390. cp->xmin = cp->ymin = 0x7fff;
  1391. cp->xmax = cp->ymax = 0x8000;
  1392. if (colormac && (!cp->cs.nocolor)) SetStdCProcs(&(cp->myProcs));
  1393. else SetStdProcs((QDProcs *)&(cp->myProcs));
  1394. (cp->PictPtr)->grafProcs = (QDProcs *)&(cp->myProcs);
  1395. cp->myProcs.putPicProc = (Ptr)myStdPutPic;
  1396. GetPort(&gp);
  1397. SetPort(cp->PictPtr);
  1398. TextFont(4);
  1399. cp->picthandle = 0;
  1400. cp->picthandle = OpenPicture(&(cp->PictPtr)->portRect);
  1401. ShowPen();
  1402. PicComment(picDwgBeg, 0, 0L);        /* start MacDraw Picture */
  1403. PicComment(picGrpBeg, 0, 0L);        /* begin a group */
  1404. cp->theWidth = NewHandle((Size)sizeof(Point));
  1405. if (cp->theWidth != 0) {
  1406.     ((Point *)(*(cp->theWidth)))->v = 1;
  1407.     ((Point *)(*(cp->theWidth)))->h = 3;        /* use 1/3 normal width */
  1408.     PicComment(SetLineWidth, sizeof(Point), cp->theWidth);    /* set new line width */
  1409.     }
  1410. cp->pictcount = sizeof(Picture);
  1411. SetPort(gp);
  1412. }
  1413.  
  1414. void closepictfile(cnr *cp)
  1415. {
  1416. OSErr rc;
  1417. GrafPtr gp;
  1418. long iocount, pictpos;
  1419. struct pictfixed {
  1420.     short    pictlen;
  1421.     Rect    pictrect;
  1422.     } pf;
  1423.  
  1424. GetPort(&gp);
  1425. SetPort(cp->PictPtr);
  1426. PicComment(picGrpEnd, 0, 0L);        /* end a group */
  1427. PicComment(picDwgEnd, 0, 0L);        /* end MacDraw Picture */
  1428. HidePen();
  1429. ClosePicture();
  1430. TextFont(cp->stdfont);
  1431.  
  1432. /* save the current file position */
  1433. if (cp->picterr == 0) {
  1434.     cp->picterr = GetFPos(cp->pictfref, &pictpos);
  1435.     }
  1436.     
  1437. /* set position after MacDraw header */
  1438. if (cp->picterr == 0) {
  1439.     cp->picterr = SetFPos(cp->pictfref, fsFromStart, (long)512);
  1440.     }
  1441.  
  1442. /* copy fixed picture fields */
  1443. memcpy(&pf, (Ptr)(*(cp->picthandle)), sizeof(struct pictfixed));
  1444. /* adjust rectangle to match actual plot */
  1445. pf.pictrect.top = cp->ymin;
  1446. pf.pictrect.left = cp->xmin;
  1447. pf.pictrect.bottom = cp->ymax;
  1448. pf.pictrect.right = cp->xmax;
  1449.  
  1450. /* write the final fixed picture fields */
  1451. if (cp->picterr == 0) {
  1452.     iocount = sizeof(struct pictfixed);
  1453.     cp->picterr = FSWrite(cp->pictfref, &iocount, &pf);
  1454.     }
  1455.  
  1456. /* reset the file position to the end */
  1457. if (cp->picterr == 0) {
  1458.     cp->picterr = SetFPos(cp->pictfref, fsFromStart, pictpos);
  1459.     }
  1460.     
  1461. KillPicture(cp->picthandle);
  1462. SetPort(gp);
  1463. (cp->PictPtr)->grafProcs = 0;
  1464. rc = FSClose(cp->pictfref);
  1465. if (cp->theWidth != 0) {
  1466.     DisposHandle(cp->theWidth);
  1467.     }
  1468. cp->pictopen = 0;
  1469. if ((rc != 0) || (cp->picterr != 0)) {
  1470.     stoperr(wpictalrt, cp);
  1471.     FSDelete(cp->pict_fName, cp->pictvref);
  1472.     }
  1473. }
  1474.  
  1475. pascal void myStdPutPic(Ptr dataPtr, unsigned short byteCount)
  1476. {
  1477. long iocount;
  1478.  
  1479. if (pictcp->picterr != 0) return;
  1480. iocount = byteCount;
  1481. pictcp->pictcount += byteCount;
  1482. pictcp->picterr = FSWrite(pictcp->pictfref, &iocount, dataPtr);
  1483. if (pictcp->picthandle != 0) (*(pictcp->picthandle))->picSize = pictcp->pictcount;
  1484. }
  1485.  
  1486. void hexdump(unsigned char *data, short len, cnr *cp)        /*temp*/
  1487. {
  1488. short count, i;
  1489. FILE * fp;
  1490.  
  1491. if (!cf_dblevel) return;
  1492.  
  1493. if (cp->openflg == 0) {
  1494.     fp = fopen("Ram:wsfdebug", "w");
  1495.     if (fp == 0) return;
  1496.     cp->openflg = 1;
  1497.     }
  1498. else {
  1499.     fp = fopen("Ram:wsfdebug", "a");
  1500.     if (fp == 0) return;
  1501.     }
  1502. fprintf(fp, "wsf_op = %x, wsf_gr = %x, grf_op = %x, length = %d\n",
  1503.     cp->wsfdbg.wsf_op, cp->wsfdbg.wsf_gr, cp->wsfdbg.grf_op, len);
  1504.  
  1505. count = 0;
  1506. for (i=0; i < len; i++) {
  1507.     fprintf(fp, "%02x", data[i]);
  1508.     count++;
  1509.     if (count == 32) {
  1510.         fprintf(fp, "\n");
  1511.         count = 0;
  1512.         }
  1513.     }
  1514. if (count != 0) fprintf(fp, "\n");
  1515. fprintf(fp, "\n");
  1516. fclose(fp);
  1517. }
  1518.